package pokerlan;

/**
 *
 * @author Administrador
 */

/**
 *
 * Esta clase maneja las apuestas por grupos. Es útil manejarlas por grupos
 * para ocasiones en las que un jugador se queda sin fichas.
 *
 * En tablaApuesta[1][x] se almacenan las fichas apostadas actualmente por el
 * jugador x.
 * En tablaApuesta[0][x] se almacena el estado del jugador. Son los siguientes:
 * 0 = Se ha plantado, 1 = Está jugando pero hay una apuesta más alta que la suya
 * y tiene que igualar, 2 = Está jugando y su apuesta es igual a la más alta, 3 = Está
 * jugando y va con All-in, 4 = Está jugando, esta igualado y viene de un grupoApuesta anterior.
 * En subidor se guarda el número del jugador que hizo la subida para saber quien
 * es el que empezará apostando la siguiente ronda.
 */
public class GrupoApuesta {
    public int[][] tablaApuesta = new int[2][9];
    public int apuestaAlta;
    public boolean hayAllIn;
    public int allInGrupo;


    /**
     * Por defecto se crea la tablaApuesta con todos los jugadores jugando y con
     * apuesta igual a la más alta. Un método externo se encargará de ir
     * modificando el estado de los jugadores.
     */
    GrupoApuesta(){
        for(int x=0; x<9; x++){
            tablaApuesta[0][x] = 2;
            if(mecanicaJuego.mesa[x] == null)
                tablaApuesta[0][x] = 0;
        }
        for(int x=0; x<9; x++){
            tablaApuesta[1][x] = 0;
        }
        hayAllIn = false;

    }


    /**
     *
     * @param tablaApuesta Es la tabla resultante de un grupoApuesta anterior.
     * @param posicion Es la posicion por donde se quedó la apuesta anterior.
     */
    GrupoApuesta(int[][] tablaApuesta){
        hayAllIn = false;
        apuestaAlta = 0;
        for(int x=0; x<9; x++){
            this.tablaApuesta[0][x] = tablaApuesta[0][x];
            this.tablaApuesta[1][x] = tablaApuesta[1][x];
            if(tablaApuesta[0][x] == 3)
                hayAllIn = true;
            if(tablaApuesta[1][x] > apuestaAlta)
                apuestaAlta = tablaApuesta[1][x];
        }
    }


    /**
     * Se agrega/actualiza la apuesta de un jugador. Externamente se debe comprobar
     * el estado del jugador. Una vez que se realiza la apuesta se actualiza el
     * estado del resto de jugadores. Si la apuesta es un All-In y es menor que otro
     * All-In, el All-In del grupo de apuesta toma el valor del introducido más bajo.
     * Si no hay ningún All-In en la apuesta se encarga de ponerlo en true.
     * @param idJugador El número identificativo del jugador (del 0 al 8).
     * @param estadoJugador El estado del jugador. En la descripción de la clase se explica.
     * @param fichasApuesta Fichas que agrega el jugador a la apuesta.
     */
    public void introducirApuesta(int idJugador, int estadoJugador, int fichasApuesta){
        if(estadoJugador == 3 && (((fichasApuesta + tablaApuesta [1][idJugador]) < allInGrupo) || hayAllIn == false)){
            allInGrupo = fichasApuesta + tablaApuesta [1][idJugador];
            hayAllIn = true;
            }
        if((fichasApuesta + tablaApuesta [1][idJugador]) > apuestaAlta){
            apuestaAlta = fichasApuesta + tablaApuesta [1][idJugador];
            }
        tablaApuesta [0][idJugador] = estadoJugador;
        tablaApuesta [1][idJugador] = tablaApuesta [1][idJugador] + fichasApuesta;
        this.actualizarEstados();
        }


    /**
     * Esta clase se encarga de recorrer la lista y actualizar los estados de los jugadores.
     */
    public void actualizarEstados(){
        for(int i=0; i<9; i++){
            if((tablaApuesta[0][i] == 2 || tablaApuesta[0][i] == 4) && (tablaApuesta[1][i] < apuestaAlta))
                tablaApuesta[0][i] = 1;
        }
    }


    /**
     *
     * @return Devuelve una tabla apuesta con las fichas sobrantes de esta apuesta
     * asignadas a cada jugador y todos los que han igualado o superado el All-in
     * que aún tienen fichas se les da el estado 2 y a los demás el estado 0.
     * A los que hicieron All-in pero superan el All-in de otro jugador se les da
     * el estado 3.
     */
    public int[][] siguienteApuesta(){
        int[][] tablaSiguienteApuesta = new int[2][9];
        for(int x=0; x<9; x++){
            if(tablaApuesta[0][x] == 0 || ((tablaApuesta[0][x] == 3)&&tablaApuesta[1][x] - allInGrupo == 0)  || tablaApuesta[0][x] == 1){
                tablaSiguienteApuesta[0][x] = 0;
                tablaSiguienteApuesta[1][x] = 0;
            }
            else{
                if(tablaApuesta[0][x] == 3){
                    tablaSiguienteApuesta[0][x] = 3;
                    tablaSiguienteApuesta[1][x] = tablaApuesta[1][x] - allInGrupo;
                }
                else{
                    tablaSiguienteApuesta[0][x] = 4;
                    tablaSiguienteApuesta[1][x] = tablaApuesta[1][x] - allInGrupo;
                }
            }
        }
        return tablaSiguienteApuesta;
    }


    /**
     * Comprueba si esta ronda de apuestas se ha terminado. Si ha terminado
     * devuelve true, y si no devuelve false.
     * @return
     */
    public boolean comprobarEstados(){
        boolean terminado = true;
        for(int i=0; i<9; i++){
            if((tablaApuesta[0][i] == 1) || (tablaApuesta[0][i] == 4))
                terminado = false;
        }
        return terminado;
    }

    public static int[][] resolverGrupoApuestas(GrupoApuesta Apuesta){
        if(Apuesta.hayAllIn == false)
            return null;
        else{
            GrupoApuesta temporal = new GrupoApuesta();
            for(int i=0; i<9; i++){
                if(Apuesta.tablaApuesta[0][i] == 2 || Apuesta.tablaApuesta[0][i] == 3){
                    if(Apuesta.tablaApuesta[1][i] > Apuesta.allInGrupo){
                        temporal.tablaApuesta[1][i] = Apuesta.tablaApuesta[1][i] - Apuesta.allInGrupo;
                        Apuesta.tablaApuesta[1][i] = Apuesta.allInGrupo;
                    }
                    if(Apuesta.tablaApuesta[0][i] == 3){
                        if(Apuesta.tablaApuesta[1][i] <= Apuesta.allInGrupo){
                            temporal.tablaApuesta[0][i] = 0;
                        }
                        else{
                            temporal.tablaApuesta[0][i] = 3;
                            if(temporal.hayAllIn == false){
                                temporal.hayAllIn = true;
                                temporal.allInGrupo = temporal.tablaApuesta[1][i];
                            }
                            else{
                                if(temporal.allInGrupo > temporal.tablaApuesta[1][i])
                                    temporal.allInGrupo = temporal.tablaApuesta[1][i];
                            }
                        }
                    }
                    else{
                        temporal.tablaApuesta[0][i] = 4;
                    }
                }
                else
                    temporal.tablaApuesta[0][i] = 0;
            }
        return temporal.tablaApuesta;
        }
    }

    public static int contarJugadores(GrupoApuesta Apuestas){
        int jugadores = 0;
        for(int i=0; i<9; i++){
            if(Apuestas.tablaApuesta[0][i] != 0)
                jugadores ++;
        }
        return jugadores;
    }
    
}
